package com.ld.util;

import com.ld.entity.PageEntity;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: 对list集合进行分页排序
 * @Author: ld
 * @Date: 2021-02-02 15:29
 */
public class PageUtil {

    private PageUtil() {

    }


    /**
     * 分页处理
     *
     * @param basePageEntity 分页条件
     * @param list           分页数据
     * @return 返回分页后的数据
     */
    public static <E> PageEntity<List<E>> basePageEntity(PageEntity<E> basePageEntity, List<E> list) {
        if (basePageEntity.getPageNum() <= 0) basePageEntity.setPageNum(1);
        if (basePageEntity.getPageSize() <= 0) basePageEntity.setPageSize(20);
        PageEntity<List<E>> pageEntity = new PageEntity<>();
        pageEntity.setPageSize(basePageEntity.getPageSize());
        pageEntity.setPageNum(basePageEntity.getPageNum());
        pageEntity.setSortBy(basePageEntity.getSortBy());
        pageEntity.setOrderBy(basePageEntity.getOrderBy());
        pageEntity.setTotalSize((long) list.size());
        pageEntity.setData(divisionList(list, pageEntity.getPageNum(), pageEntity.getPageSize(), pageEntity.getOrderBy(), pageEntity.getSortBy()));
        return pageEntity;
    }

    /**
     * @param entity 过滤条件实体
     * @param list   待过滤数据列表
     * @return 返回过滤后的数据列表
     */
    public static <E> List<E> getByEntityFilter(E entity, List<E> list) {
        return list.stream().filter(x -> {
            try {
                Method[] methods = entity.getClass().getDeclaredMethods();
                List<Boolean> booleanList = new ArrayList<>();
                for (Method method : methods) {
                    if (method.getName().contains("get")
                            && method.invoke(entity) != null
                            && !method.invoke(entity).equals("")) {
                        booleanList.add(method.invoke(x).toString().equals(method.invoke(entity).toString()));
                    }
                }
                return booleanList.isEmpty() || booleanList.stream().allMatch(y -> y);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }).collect(Collectors.toList());

    }

    /**
     * 分页排序
     *
     * @param list     待处理列表
     * @param pageNum  页数
     * @param pageSize 分页大小
     * @param orderBy  根据什么排序
     * @param sortBy   正序反序（asc、desc）
     * @param <E>      任意对象
     * @return 处理好的数据
     */
    public static <E> List<E> divisionList(List<E> list, int pageNum, int pageSize, String orderBy, String sortBy) {
        int total = list.size();
        int startIndex = pageNum * pageSize - pageSize;
        int endIndex = pageNum * pageSize;
        if (total < startIndex) {
            startIndex = total;
        }
        if (total < endIndex) {
            endIndex = total;
        }
        if (orderBy != null && !"".equals(orderBy)) {
            sort(list, orderBy, sortBy);
        }
        return list.subList(startIndex, endIndex);
    }

    /**
     * 对List进行排序操作
     *
     * @param list    需要排序的列表
     * @param orderBy 需要进行排序的对象字段（需要含有相应的get方法）
     * @param sort    asc 正序，desc 反序
     * @param <E>     泛型
     */
    public static <E> void sort(List<E> list,  String orderBy,  String sort) {
        String methodName = "get" + orderBy.toUpperCase().substring(0, 1).toUpperCase() + orderBy.substring(1);
        list.sort((a, b) -> {
            int ret = 0;
            try {
                Method m1 = a.getClass().getMethod(methodName, null);
                Method m2 = b.getClass().getMethod(methodName, null);
                String rs1 = null;
                String rs2 = null;
                if (m1.invoke(a, null) != null) {
                    rs1 = m1.invoke(a, null).toString();
                }
                if (m2.invoke(a, null) != null) {
                    rs2 = m2.invoke(b, null).toString();
                }

                //判断字符串是否为数字，若为数字则直接加减
                if (rs1 != null && rs2 != null && rs1.matches("-?[0-9]+.?[0-9]*")) {
                    if ("desc".equals(sort)) {
                        ret = Integer.valueOf(rs2).compareTo(Integer.valueOf(rs1));
                    } else {
                        ret = Integer.valueOf(rs1).compareTo(Integer.valueOf(rs2));
                    }
                } else if (rs1 != null && rs2 != null) {
                    if ("desc".equals(sort))//倒序
                        ret = rs2.compareTo(rs1);
                    else//正序
                        ret = rs1.compareTo(rs2);
                }
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ne) {
                ne.printStackTrace();
            }
            return ret;
        });
    }
}
